#grep command

[nixcraft]

See, that is why Redhat and Mr. Poettering have introduced all in one systemd command that does grep command and limiting output in a single go for a given service log. How cool is that? You guys hate systemd for no good reason 🤭

journalctl -u nginx.service -g failed -n 10

See also Linux Log Files Location And How Do I View Logs Files on Linux? for more info.

[arashtadstudio]

Mastering the grep Command in Linux

Unlock the full power of grep in Linux with this comprehensive tutorial! Whether you're a beginner or an advanced user, learn how to effectively search, filter, and manipulate text files and logs using the powerful grep command. Mastering this tool will save you time and boost your productivity.

In this video, we cover everything from basic usage to advanced techniques including regular expressions, recursive search, and context filtering. By the end of this video, you’ll be using grep like a pro, making it an essential tool in your Linux toolkit.

Setting up the environment for grep – Learn how to set up directories and files for testing common use cases like log analysis.

Basic grep usage – Search for exact string matches with options like -i (case-insensitive) and -n (line numbers).

Recursive search – Use grep to search through all files and subdirectories with the -r flag.

Regular Expressions – Discover how to search for complex patterns using grep's extended regex capabilities.

Showing context – Learn how to display lines before (-B), after (-A), and around matches (-C) to give more context to your searches.

Advanced grep options – Count matches (-c), invert matches (-v), match whole words (-w), and more.

Color-coded output – Enable colored output for better visibility of matches.

Using grep with pipes and output redirection – Combine grep with other commands and redirect output to files.

grep "pattern" filename

grep -r "pattern" .

grep -E "Error|Warning"

grep -B 1 "Warning"

grep -C 1 "Error"

grep --color=always "pattern"

grep "pattern" file > output.txt

[ramniwas-sangwan]

Mastering Regular Expressions and the grep Command in Linux | Linux Tuto...

[aflo]

we opened up one of our old testing scripts at work and found that the script writer manually coded an xref table to define every single host in the system both ways. there's nearly 10K hosts in our system. you can pull that data with a 1-line grep command.

[hbbisenieks]

top 5 Unix commands?

Easy!

1. grep: fucking Find things

2. awk: it was almost a tie between this and sed but I use awk more often. Manipulating data my beloved

3. sed: even if you just use it to disemvowel things, it's great, but it does so much more

4. vim: "but hilary that's a full editor" fuck off this is my post and vim is great arguably I could have put this at position one and I would be right to do so

5. sudo: it's Simon says rules

[liquidcrystalsky]

WSL recently went open source but even before then it was really good.

Windows Subsystem for Linux is a thing by microsoft which just allows you to run linux inside of your windows PC. I just used it whenever i needed some command line tooling or shit that windows doesn't have (grep, wc, openssl) but i found out only a billion years later it can run full gui apps (just download them and run them from the command line) or you can also run an Entire Desktop environment to basically just have a Linux system inside of your windows installation without any virtual machines or messing about with dual booting or partitioning.

WSL will run a lot worse than normal linux however its (i think) much easier to set up and you can access all your normal windows files from it as well.

It would be good to try if you want to switch to linux but you wanna try it out, however i dont think i have any windows devices anymore to see how well it works and how easy it is to set up a DE

[sentientcitysurvival]

Basic Linux Security (Updated 2025)

Install Unattended Upgrades and enable the "unattended-upgrades" service.

Install ClamAV and enable "clamav-freshclam" service.

Install and run Lynis to audit your OS.

Use the "last -20" command to see the last 20 users that have been on the system.

Install UFW and enable the service.

Check your repo sources (eg; /etc/apt/).

Check the /etc/passwd and /etc/shadow lists for any unusual accounts.

User the finger command to check on activity summaries.

Check /var/logs for unusual activity.

Use "ps -aux | grep TERM" or "ps -ef | grep TERM" to check for suspicious ongoing processes.

Check for failed sudo attempts with "grep "NOT in sudoers" /var/log/auth.log.

Check journalctl for system messages.

Check to make sure rsyslog is running with "sudo systemctl status rsyslog" (or "sudo service rsyslog status") and if it's not enable with "sudo systemctl enable rsyslog".

Perform an nmap scan on your machine/network.

Use netstat to check for unusual network activity.

Use various security apps to test you machine and network.

Change your config files for various services (ssh, apache2, etc) to non-standard configurations.

Disabled guest accounts.

Double up on ssh security by requiring both keys and passwords.

Check your package manager for any install suspicious apps (keyloggers, cleaners, etc).

Use Rootkit Scanners (chkrootkit, rkhunter).

Double SSH Security (Key + Password).

Disabled Guest Accounts.

Enabled Software Limiters (Fail2Ban, AppArmor).

Verify System Integrity via fsck.

Utilize ngrep/other networking apps to monitor traffic.

Utilize common honeypot software (endlessh).

Create new system-launch subroutines via crontab or shell scripts.

Ensure System Backups are Enabled (rsnapshot).

Check for suspicious kernel modules with "lsmod"

[cutecipher]

The body if it were linux commands

head

grep

tail

[astercontrol]

Hey! Question for anyone out there who

is working on archiving stuff in case it gets lost, and

is more familiar with coding than I am.

---

I've been backing up my Tumblr regularly for years now. I'm trying very hard to get into the habit of saving everything I create that's of value to me and NOT relying on a website I can't control to keep it saved…

And the problem with Tumblr's innate "download-a-backup" function is that once you've downloaded it, it seems you can't fully access it unless your Tumblr blog still exists and you have an internet connection capable of viewing it.

Which, like, defeats the whole purpose of a backup?

???

And there is no reason that HAS to be the case! The backup does download the text of all your posts, and a copy of every image you've ever posted! You CAN look at all these things individually, on your computer, in the backup folder you downloaded, without accessing the internet at all.

But for some incomprehensible reason, the backup doesn't create real links between them!

At least, not the images.

It does give you a whole lot of individual html documents containing the text of your posts. And it does give you a big "index" html document with links to all of those.

---

---

And as far as I can tell, all of THAT works fine, whether you access it on your own private computer, or upload it all to your own self-hosted html website, or whatever.

But the images embedded in those posts are NOT the copies that you have in the big, huge, giant image folder that you went to all that trouble to download with your backup!

They're the copies that Tumblr still has stored on THEIR website somewhere.

And the images will not show up in your downloaded posts, unless 1. Tumblr still has that content from your Tumblr blog up on their site, and 2. you are connected to the internet to see it.

So… the whole Tumblr download thing feels kinda useless. Unless we can fix that.

---

There are apparently other methods of downloading one's Tumblr blog. But from what I've read, the reliable methods that actually produce a usable archive with embedded images?... are methods that require using the command terminal on your computer.

I am not enough of a programmer to feel comfortable with that.

Maybe, if someone could give me good enough instructions that I could trust not to mess up other stuff on my computer in the process, I might try it.

But right now, I'm just focused on trying to fix the archive I already downloaded.

---

The closest I get to being a programmer is editing html documents in a code editor. (I have BBEdit for Mac, the full paid version.)

And I've made some progress in learning GREP (regex) commands in there. Because that's basically an extra-specialized version of doing search-and-replace in a document, and the logic of it makes a lot of intuitive sense to me.

Anyway. To illustrate what I'm saying. Here is the link to a post of mine on Tumblr with 2 embedded images.

It is a slightly hornyish post, and LGBTQ-focused, and contains an image from a movie copyrighted by a very litigious corporation.

And I'm not saying any of that, in itself, is enough to fear for its continued existence on Tumblr.

BUT, I'm not saying I 100% trust Tumblr with it, either.

So.... because of that, and the fact that it contains two embedded images with different extensions.... it's a good example to run my tests on.

Here is a screenshot of what it looks like on Tumblr:

---

---

Here is what the post looks like in the folders generated by the backup:

---

---

The "style.css" document in the folder is what it uses for some of the formatting. Which is pretty, but not necessary.

Html documents stored on your computer can be opened in a web browser, same as websites. Here is what that html document looks like if I open it in Firefox-- while it's that same folder-- with my internet connection turned on.

---

---

Here is what it looks like if I open it after moving it to a different folder-- internet connection still on, but no longer able to access that stylesheet document, because it's not in the same folder.

---

---

Either one of those looks would be fine with me. (And the stylesheet doesn't NEED the connection to Tumblr or the internet at all, so it is a valid part of a working backup.)

But here's where the problem starts.

These are the two images that this post uses. They're in another folder within the backup folder I downloaded:

---

---

But the downloaded html document of the post doesn't use them in the same way it uses the stylesheet.

It doesn't use them AT ALL.

Instead it uses whole different copies of them, from Tumblr's goddamn WEBSITE.

This is what the downloaded post looks like when I do NOT have an internet connection.

(First: from the same folder as the css stylesheet. Second: from a different folder without access to the stylesheet.)

---

---

Without internet, it won't show the pictures.

There is NO REASON this has to happen.

And I should be able to fix it!

---

This is what the code of that damn HTML page looks like, when I open it in my code editor.

---

---

First, it contains a lot of stuff I don't need at all.

I want to get rid of all the "scrset" stuff, which is just to provide different options for optimizing the displayed size of the images, which is not particularly important to me.

Which I do using the Grep command (.*?) to stand in for all that.

---

---

This, again, is basically just a search and replace. I'm telling the code editing program to find all instances of anything starting with srcset= and ending with a slash and close-caret, and replace each one with just the slash and close-caret.

This removes all the "srcset" nonsense from every image-embed.

Which makes my document easier for me to navigate, as I face the problem that the image-embeds still link to goddamn Tumblr.

---

---

My goal here is to replace those Tumblr links:

img src="https://64.media.tumblr.com/887612a62e9cdc3869edfda8a8758b52/0eeed3a3d2907da3-7c/s640x960/8fe9aea80245956a302ea22e94dfbe2c3506c333.jpg"

and

img src="https://64.media.tumblr.com/67cdeb74e9481b772cfeb53176be9ad8/0eeed3a3d2907da3-c6/s640x960/785c70ca999dc44e4d539f1ad354040fd8ef8911.png"

with links to the actual images I downloaded.

Now, if I were uploading all this backup to my own personally-hosted site, I would want to upload the images into a folder there, and make the links use images from that folder on my website.

But for now, I'm going to try and just make them go to the folder I have on my computer right now.

So, for this document, I'll just manually replace each of those with img src="(the filename of the image)."

---

---

Tumblr did at least do something to make this somewhat convenient:

it gave the images each the same filename as the post itself

except with the image extension instead of .html

(one of the images is a .jpg and the other is a .png)

and with numbers after the name (_0 and _1) to denote what order they're in.

This at least made the images easy to find.

And as long as I keep the images and the html post in the same folder--

and keep that folder within the same folder as a copy of the stylesheet--

---

---

--then all the formatting works, without any need for a connection to Tumblr's website.

---

---

Now.

If only I knew how to do that with ALL the posts in my archive, and ALL their embedded images.

And this is where my search-and-replace expertise has run out.

I know how to search and replace in multiple html documents at once. But I don't know how to do it for this specific task.

What I need, now, is a set of search-and-replace commands that can:

change every image-embed link in each one of those hundreds of html posts-- all that "https://64.media.tumblr.com/(two lines of random characters).(extension)" bullshit--

replacing the (two lines of random characters) with just the same text as the filename of whichever html document it's in.

then, add a number on the end of every filename in every image-embed-- so that within each html document, the first embed has a filename that ends in _0 before the image extension, and the second ends in _1, and so on.

I am fairly sure there ARE automated ways to do this. If not within the search-and-replace commands themselves, then some other option in the code editor.

Anyone have any insights here?

[mesaprotector]

Clarity trumps efficiency.

*I would've liked to write this essay to be understandable for someone without a programming/Linux background, but it was a bit too difficult. If you skip to the paragraph beginning with "...", it gets a bit easier from then on.

If you’ve ever written your own shell scripts you may have heard of the phrase “useless use of cat*”, or less tactfully, “cat abuse”. This refers to the practice, common among new shell script enthusiasts, of writing commands like “cat file.txt | grep name”, when “grep name file.txt” would serve perfectly well. Tools like shellcheck will bug you about it—along with similar constructions like “ps ax | grep Discord | wc -l” instead of “pgrep -c Discord”.

Well, I’m here to defend cat abuse! There are two arguments I see against the cat | grep construction, one of which is valid but situational, and the other of which is completely invalid. The former is that the extra pipe just adds additional overhead into the command. Yes, it does. And it’s unlikely to matter at all if you’re using it on 20KiB text files on a system built in the past 40 years; however, in production, when writing tools that need to be able to deal with arbitrarily large text files as efficiently as possible, sure.

The latter is “well, it’s just unnecessary”. I disagree. I think the cat | grep construction—along with similar such as grep | wc, ps | grep, ps | awk, and so on—serves a very important purpose in that it makes shell scripts easier to read, easier to modify, and easier to debug.

Consider this example from above:

ps ax | grep Discord | wc -l

Read the process table; filter for "Discord"; count the number of lines. It’s very atomic. Each operation can be swapped out for something else without confusing the reader. On the other hand:

pgrep -c Discord

Now, this does the same thing—counting the number of lines in the process table with "Discord" in them. It looks like only one operation... but it’s really still three in disguise. And worse, imagine you suddenly want to add another filter; sorting not only by Discord, but by processes that include the word “title”. This is not straightforward at all! It turns out that while regex has a standard way of searching for alternatives, it really does not provide an easy method for searching for BOTH of two words. On the other hand, with the atomic version, it’s easy:

ps ax | grep Discord | grep title | wc -l

Take that, “useless” use of cat.

There’s a broader meaning, though, to my statement of “clarity trumps efficiency”. I apply it to every aspect of use of electronics, from web searches to backup routines to yes, silly little shell scripts that use cat.

I use command aliases, but to a pretty limited degree; I avoid cutesy stuff like “ll” for “ls -l” and “yeet” for “pacman -Rns”, along with possibly-dangerous substitutions like “rm” for “rm -i”; I’d never dream of aliasing “nano” or “vi” to my preferred text editor (vim). I believe strongly that my commands should be transparent, and saving me from my own muscle memory once or twice is not worth making them completely opaque.

Tab completion on the other hand is one of my favorite features in the shell. It’s the perfect combination of transparent and convenient; without having to alias any of my application names or get hit by the information overload fuzzy finding gives you, I can still launch any of them in no more than four keystrokes. (Except audacious and audacity, admittedly.)

I use a floating window manager (Openbox), and when I need to briefly use a tiling layout, I have a very boring way of doing so: focusing each window one by one and moving it into the slot I want. (While holding down the Super/Windows key, 1-C-2-V does a basic left-right split.)

... I make some use of spellcheck on assignments to be turned in, but never autocorrect, which I abhor even in messaging apps. Every change to your inputs should be deliberate; otherwise you’ll never learn what you’re doing wrong, and you’ll never need to be precise because you’ve turned over that part of your brain to the algorithm.

This leads me to an important corollary of my principle: “it’s better to have a slow algorithm that you understand, than a fast one that you don’t”.

Satya Nadella’s vision of the PC of the future is one where you tell it what to do in natural language and it interprets that using LLMs and so on into machine instructions. Instead of viewing a PC as a toolbox you go into the workshop with, and work on projects with in certain defined ways, he wants the PC to be an assistant; you give the assistant directions and pray that it gets things right. Of course you aren’t allowed into the workshop with the tools anymore; that’s the assistant’s job!

Anyone who’s used Google Search over the past ten years knows how miserable this model is; you search for a specific phrase that Google “helpfully” corrects to something it thinks you meant. There was a learning curve to the old way, but once you learned how to state queries precisely, you were done; now you need to play psychologist, sociologist, and statistician all at once.

This is a decent part of why I dislike generative AI, though far from the main reason. I don’t want an opaque algorithm making decisions for me, unless those decisions are incredibly low-level stuff like core parking that no human should be directly involved with in the first place.

To get back to my own setup, I have a whole text file documenting the system maintenance process I go through once every month; most of it could be automated, but I make every step a deliberate choice. Not to go all new-age, but for me specifically—it all ties back in to mindfulness.

I think people have only a vague concept of what mindfulness is. Until two years ago or so, I was the same way. But to who I am now, mindfulness means not doing anything on autopilot. Instead of letting yourself half-doze off on a drive home, scarcely remembering the 20 minutes from the parking lot to the garage, be conscious of every turn. Instead of immediately putting on music and blocking out the world on a train ride to the next city, force yourself to be present in the train car, and notice the way the light reflects on the plastic seat two rows in front.

And to me, clarity in code, and in UX, is a part of this mindfulness. Programs that are easy to read, easy to modify, and easy to debug encourage you to look closer—to consider every atom that goes into their statements instead of taking them for granted. Slow algorithms that you understand can help you think of improvements; fast algorithms that you don’t encourage you to give up and leave the real thinking to someone else.

So write silly little shell scripts with five pipes in a single statement, and yes, that uselessly use cat. Rather than doing anything wrong—you’re allowing yourself and others to think, to try, and to improve.

[elite-amarys]

case $- in     i) ;;       *) return;; esac

don't put duplicate lines or lines starting with space in the history.

See bash(1) for more options

HISTCONTROL=ignoreboth

append to the history file, don't overwrite it

shopt -s histappend

for setting history length see HISTSIZE and HISTFILESIZE in bash(1)

HISTSIZE=1000 HISTFILESIZE=2000

check the window size after each command and, if necessary,

update the values of LINES and COLUMNS.

shopt -s checkwinsize

If set, the pattern "**" used in a pathname expansion context will

match all files and zero or more directories and subdirectories.

shopt -s globstar

make less more friendly for non-text input files, see lesspipe(1)

[ -x /usr/bin/lesspipe ] && eval "$(SHELL=/bin/sh lesspipe)"

set variable identifying the chroot you work in (used in the prompt below)

if [ -z "${debian_chroot:-}" ] && [ -r /etc/debian_chroot ]; then     debian_chroot=$(cat /etc/debian_chroot) fi

set a fancy prompt (non-color, unless we know we "want" color)

case "$TERM" in     xterm-color|*-256color) color_prompt=yes;; esac

uncomment for a colored prompt, if the terminal has the capability; turned

off by default to not distract the user: the focus in a terminal window

should be on the output of commands, not on the prompt

force_color_prompt=yes

if [ -n "$force_color_prompt" ]; then     if [ -x /usr/bin/tput ] && tput setaf 1 >&/dev/null; then

We have color support; assume it's compliant with Ecma-48

(ISO/IEC-6429). (Lack of such support is extremely rare, and such

a case would tend to support setf rather than setaf.)

color_prompt=yes     else color_prompt=     fi fi

if [ "$color_prompt" = yes ]; then     PS1='${debian_chroot:+($debian_chroot)}[\033[01;32m]\u@\h[\033[00m]:[\033[01;34m]\w[\033[00m]\$ ' else     PS1='${debian_chroot:+($debian_chroot)}\u@\h:\w\$ ' fi unset color_prompt force_color_prompt

If this is an xterm set the title to user@host:dir

case "$TERM" in xterm|rxvt)     PS1="[\e]0;${debian_chroot:+($debian_chroot)}\u@\h: \w\a]$PS1"     ;; *)     ;; esac

enable color support of ls and also add handy aliases

if [ -x /usr/bin/dircolors ]; then     test -r ~/.dircolors && eval "$(dircolors -b ~/.dircolors)" || eval "$(dircolors -b)"     alias ls='ls --color=auto'     #alias dir='dir --color=auto'     #alias vdir='vdir --color=auto'

    alias grep='grep --color=auto'     alias fgrep='fgrep --color=auto'     alias egrep='egrep --color=auto' fi

colored GCC warnings and errors

export GCC_COLORS='error=01;31:warning=01;35:note=01;36:caret=01;32:locus=01:quote=01'

some more ls aliases

alias ll='ls -alF' alias la='ls -A' alias l='ls -CF'

Add an "alert" alias for long running commands.  Use like so:

  sleep 10; alert

alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s[0-9]+\s//;s/[;&|]\s*alert$//'\'')"'

Alias definitions.

You may want to put all your additions into a separate file like

~/.bash_aliases, instead of adding them here directly.

See /usr/share/doc/bash-doc/examples in the bash-doc package.

if [ -f ~/.bash_aliases ]; then     . ~/.bash_aliases fi

enable programmable completion features (you don't need to enable

this, if it's already enabled in /etc/bash.bashrc and /etc/profile

sources /etc/bash.bashrc).

if ! shopt -oq posix; then   if [ -f /usr/share/bash-completion/bash_completion ]; then     . /usr/share/bash-completion/bash_completion   elif [ -f /etc/bash_completion ]; then     . /etc/bash_completion   fi fi

echo poryOSwelcome

REQUEST TO ENTER COMMAND INTO BASH SHELL INTERPRETER: DENIED.

ALTERNATIVE COMMAND:

DROP TABLE IF EXISTS: YOUR LIFE.

[nixcraft]

Contrary to popular belief, "grep" doesn't actually stand for "global regular expression print." It's an acronym for "Galactic Retrieval and Extraction Protocol," originally developed by a secret group of Unix hackers to search for extraterrestrial signals hidden within log files

[lizhly-writes]

listen. listen what if i study for my exams by turning all the concepts i need to learn into characters and plots.

what if i talk about a cat made up of words. it likes eating them too, and will happily go and thieve away whatever book or document you've set aside and just eat it all. it'll give some back to you, though! you know, if you know the right command and you know what to look for.

its name is Chmod, and hanging from its collar are three tokens with numbers on it and if you grab the right token you could change the words written on its body and own it.

it leaves footprints made of words behind when it jogs, but not for long. they fade away in seconds, sent away to a mythical place called Varlog, where you can only enter if you have the right key.

anyway, this is my attempt to link together all the file manipulation commands for my exam, featuring:

cat (lets you view entire file)

head & tail (look, it's a cat, of course it has a head and tail, and each of them have 10 words each)

grep (the command you need to get words from the cat)

chmod (the name of the cat, and also the command you need to change file permissions)

logger (the command to add messages to var/log/syslog and look, i figured jogging was close enough, okay)

[tpointtechblog]

Essential Linux Commands: Mastering the Basics of Command-Line Operations

Linux, a powerful and versatile operating system, offers a command-line interface that empowers users with unprecedented control over their systems. While the graphical user interface (GUI) provides ease of use, understanding the fundamental Linux commands is essential for anyone seeking to harness the full potential of this open-source platform. In this article, we will explore some of the…

Essential Linux Commands help users navigate, manage files, and control system processes. Here are some key ones:

ls – List directory contents

cd – Change directory

pwd – Show current directory path

mkdir – Create a new directory

rm – Remove files or directories

cp – Copy files or directories

mv – Move or rename files

cat – View file contents

grep – Search text in files

chmod – Change file permissions

top – Monitor system processes

ps – Display running processes

kill – Terminate a process

sudo – Execute commands as a superuser

Mastering these commands boosts productivity and system control!

[hindintech]

You can learn Git easily, Here's all you need to get started:

1.Core:

• git init

• git clone

• git add

• git commit

• git status

• git diff

• git checkout

• git reset

• git log

• git show

• git tag

• git push

• git pull

2.Branching:

• git branch

• git checkout -b

• git merge

• git rebase

• git branch --set-upstream-to

• git branch --unset-upstream

• git cherry-pick

3.Merging:

• git merge

• git rebase

4.Stashing:

• git stash

• git stash pop

• git stash list

• git stash apply

• git stash drop

5.Remotes:

• git remote

• git remote

• add git

• remote remove

• git fetch

• git pull

• git push

• git clone --mirror

6.Configuration:

• git config

• git global config

• git reset config

7. Plumbing:

• git cat-file

• git checkout-index

• git commit-tree

• git diff-tree

• git for-each-ref

• git hash-object

• git Is-files

• git Is-remote

• git merge-tree

• git read-tree

• git rev-parse

• git show-branch

• git show-ref

• git symbolic-ref

• git tag --list

• git update-ref

8.Porcelain:

• git blame

• git bisect

• git checkout

• git commit

• git diff

• git fetch

• git grep

• git log

• git merge

• git push

• git rebase

• git reset

• git show

• git tag

9.Alias:

• git config --global alias.<alias> <command>

10.Hook:

• git config --local core.hooksPath <path>

11.Experimental: (May not be fully Supported)

• git annex

• git am

• git cherry-pick --upstream

• git describe

• git format-patch

• git fsck

• git gc

• git help

• git log --merges

• git log --oneline

• git log --pretty=

• git log --short-commit

• git log --stat

• git log --topo-order

• git merge-ours

• git merge-recursive

• git merge-subtree

• git mergetool

• git mktag

• git mv

• git patch-id

• git p4

• git prune

• git pull --rebase

• git push --mirror

• git push --tags

• git reflog

• git replace

• git reset --hard

• git reset --mixed

• git revert

• git rm

• git show-branch

• git show-ref

• git show-ref --heads

• git show-ref --tags

• git stash save

• git subtree

• git taq --delete

• git tag --force

• git tag --sign

• git tag -f

• git tag -I

• git tag --verify

• git unpack-file

• git update-index

• git verify-pack

• git worktree

[vim-official]

I (24) thought I'm not bad at tech shit, but using Linux gas actually made me worse at using Windows. I am so goddamn used to having bash, vim, grep, systemd, a package manager, socket files, the etc directory, and all the other *nix niceties that I've forgotten how to use Windows beyond the very surface level of using chrome and word to make the documents that I have to email to my boss every day. I can no longer help people troubleshoot their computers. I've forgotten how to defrag the work computer because I can't `sudo btrfs filesystem defrag /`. I've been having to relearn windows shortcuts because I don't have vim commands anymore. ctrl-bksp is harder for me than dib. I was having problems with some of the work software and I couldn't troubleshoot it at all, just prove I could reproduce it on multiple computers and make a ticket with the IT guy.

I've never known how to edit the registry, and pasting arcane instructions from stackoverflow into admin powershell is not good.

even before I switched fully to Linux, when my laptop had Windows only, I was still living my life out of bashonubuntuonwindows for numerous tasks. when I still lived at Mom and Dad's and I had their hand me down computers, I kept the main laptop windows for software compat but I had a little row of the world's shittiest homelabs running Arch or Debian minimal and I'd SSH in every day to do a lot of stuff with them. this has prepared me for nothing.

We need to lay more blame for "Kids don't know how computers work" at the feet of the people responsible: Google.

Google set out about a decade ago to push their (relatively unpopular) chromebooks by supplying them below-cost to schools for students, explicitly marketing them as being easy to restrict to certain activities, and in the offing, kids have now grown up in walled gardens, on glorified tablets that are designed to monetize and restrict every movement to maximize profit for one of the biggest companies in the world.

Tech literacy didn't mysteriously vanish, it was fucking murdered for profit.